/**
 *  test4.c - Test osCreateTask() and osKill().
 *            It runs on ARMulator or ARM7TDMI CPU.
 *
 *  Copyright (C) 2008-2010 ZhangHu
 *  All rights reserved.
 *  E-MAIL: anmnmnly@gmail.com
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
#include "include\core.h"


#define STACK_SIZE 128
#define SAME_PRIO 63

#define TASKNUM 200

static tcb_t task_tcb[TASKNUM];
static stk_t task_stk[TASKNUM][STACK_SIZE];


static void Task0(void) {
    while(1) {
        osKill();
    }
}



static void Task1(void) {
    while(1) {
        osKill();
    }
}



static void Task2(void) {
    while(1) {
        osKill();
    }
}



static void Task3(void) {
    while(1) {
        osKill();
    }
}



static void Task4(void) {
    while(1) {
        osKill();
    }
}



static void Task5(void) {
    while(1) {
        osKill();
    }
}



static void Task6(void) {
    while(1) {
        osKill();
    }
}



static void Task7(void) {
    while(1) {
        osKill();
    }
}



static void Task8(void) {
    while(1) {
        osKill();
    }
}



static void Task9(void) {
    while(1) {
        osKill();
    }
}



static void Task10(void) {
    while(1) {
        osKill();
    }
}



static void Task11(void) {
    while(1) {
        osKill();
    }
}



static void Task12(void) {
    while(1) {
        osKill();
    }
}



static void Task13(void) {
    while(1) {
        osKill();
    }
}



static void Task14(void) {
    while(1) {
        osKill();
    }
}



static void Task15(void) {
    while(1) {
        osKill();
    }
}



static void Task16(void) {
    while(1) {
        osKill();
    }
}



static void Task17(void) {
    while(1) {
        osKill();
    }
}



static void Task18(void) {
    while(1) {
        osKill();
    }
}



static void Task19(void) {
    while(1) {
        osKill();
    }
}



static void Task20(void) {
    while(1) {
        osKill();
    }
}



static void Task21(void) {
    while(1) {
        osKill();
    }
}

static void Task22(void) {
    while(1) {
        osKill();
    }
}



static void Task23(void) {
    while(1) {
        osKill();
    }
}



static void Task24(void) {
    while(1) {
        osKill();
    }
}



static void Task25(void) {
    while(1) {
        osKill();
    }
}



static void Task26(void) {
    while(1) {
        osKill();
    }
}



static void Task27(void) {
    while(1) {
        osKill();
    }
}



static void Task28(void) {
    while(1) {
        osKill();
    }
}



static void Task29(void) {
    while(1) {
        osKill();
    }
}



static void Task30(void) {
    while(1) {
        osKill();
    }
}



static void Task31(void) {
    while(1) {
        osKill();
    }
}



static void Task32(void) {
    while(1) {
        osKill();
    }
}



static void Task33(void) {
    while(1) {
        osKill();
    }
}



static void Task34(void) {
    while(1) {
        osKill();
    }
}



static void Task35(void) {
    while(1) {
        osKill();
    }
}



static void Task36(void) {
    while(1) {
        osKill();
    }
}



static void Task37(void) {
    while(1) {
        osKill();
    }
}



static void Task38(void) {
    while(1) {
        osKill();
    }
}



static void Task39(void) {
    while(1) {
        osKill();
    }
}



static void Task40(void) {
    while(1) {
        osKill();
    }
}



static void Task41(void) {
    while(1) {
        osKill();
    }
}



static void Task42(void) {
    while(1) {
        osKill();
    }
}



static void Task43(void) {
    while(1) {
        osKill();
    }
}



static void Task44(void) {
    while(1) {
        osKill();
    }
}



static void Task45(void) {
    while(1) {
        osKill();
    }
}



static void Task46(void) {
    while(1) {
        osKill();
    }
}



static void Task47(void) {
    while(1) {
        osKill();
    }
}



static void Task48(void) {
    while(1) {
        osKill();
    }
}



static void Task49(void) {
    while(1) {
        osKill();
    }
}



static void Task50(void) {
    while(1) {
        osKill();
    }
}



static void Task51(void) {
    while(1) {
        osKill();
    }
}



static void Task52(void) {
    while(1) {
        osKill();
    }
}



static void Task53(void) {
    while(1) {
        osKill();
    }
}



static void Task54(void) {
    while(1) {
        osKill();
    }
}



static void Task55(void) {
    while(1) {
        osKill();
    }
}



static void Task56(void) {
    while(1) {
        osKill();
    }
}



static void Task57(void) {
    while(1) {
        osKill();
    }
}



static void Task58(void) {
    while(1) {
        osKill();
    }
}



static void Task59(void) {
    while(1) {
        osKill();
    }
}



static void Task60(void) {
    while(1) {
        osKill();
    }
}



static void Task61(void) {
    while(1) {
        osKill();
    }
}



static void Task62(void) {
    while(1) {
        osKill();
    }
}



static void Task63(void) {
    while(1) {
        osKill();
    }
}



static void Task64(void) {
    while(1) {
        osKill();
    }
}



static void Task65(void) {
    while(1) {
        osKill();
    }
}



static void Task66(void) {
    while(1) {
        osKill();
    }
}



static void Task67(void) {
    while(1) {
        osKill();
    }
}



static void Task68(void) {
    while(1) {
        osKill();
    }
}



static void Task69(void) {
    while(1) {
        osKill();
    }
}



static void Task70(void) {
    while(1) {
        osKill();
    }
}



static void Task71(void) {
    while(1) {
        osKill();
    }
}



static void Task72(void) {
    while(1) {
        osKill();
    }
}



static void Task73(void) {
    while(1) {
        osKill();
    }
}



static void Task74(void) {
    while(1) {
        osKill();
    }
}



static void Task75(void) {
    while(1) {
        osKill();
    }
}



static void Task76(void) {
    while(1) {
        osKill();
    }
}



static void Task77(void) {
    while(1) {
        osKill();
    }
}



static void Task78(void) {
    while(1) {
        osKill();
    }
}



static void Task79(void) {
    while(1) {
        osKill();
    }
}



static void Task80(void) {
    while(1) {
        osKill();
    }
}



static void Task81(void) {
    while(1) {
        osKill();
    }
}



static void Task82(void) {
    while(1) {
        osKill();
    }
}



static void Task83(void) {
    while(1) {
        osKill();
    }
}



static void Task84(void) {
    while(1) {
        osKill();
    }
}



static void Task85(void) {
    while(1) {
        osKill();
    }
}



static void Task86(void) {
    while(1) {
        osKill();
    }
}



static void Task87(void) {
    while(1) {
        osKill();
    }
}



static void Task88(void) {
    while(1) {
        osKill();
    }
}



static void Task89(void) {
    while(1) {
        osKill();
    }
}



static void Task90(void) {
    while(1) {
        osKill();
    }
}



static void Task91(void) {
    while(1) {
        osKill();
    }
}



static void Task92(void) {
    while(1) {
        osKill();
    }
}



static void Task93(void) {
    while(1) {
        osKill();
    }
}



static void Task94(void) {
    while(1) {
        osKill();
    }
}



static void Task95(void) {
    while(1) {
        osKill();
    }
}



static void Task96(void) {
    while(1) {
        osKill();
    }
}



static void Task97(void) {
    while(1) {
        osKill();
    }
}



static void Task98(void) {
    while(1) {
        osKill();
    }
}



static void Task99(void) {
    while(1) {
        osKill();
    }
}



static void Task100(void) {
    while(1) {
        osKill();
    }
}



static void Task101(void) {
    while(1) {
        osKill();
    }
}



static void Task102(void) {
    while(1) {
        osKill();
    }
}



static void Task103(void) {
    while(1) {
        osKill();
    }
}



static void Task104(void) {
    while(1) {
        osKill();
    }
}



static void Task105(void) {
    while(1) {
        osKill();
    }
}



static void Task106(void) {
    while(1) {

        osKill();
    }
}



static void Task107(void) {
    while(1) {
        osKill();
    }
}



static void Task108(void) {
    while(1) {
        osKill();
    }
}



static void Task109(void) {
    while(1) {
        osKill();
    }
}



static void Task110(void) {
    while(1) {
        osKill();
    }
}



static void Task111(void) {
    while(1) {
        osKill();
    }
}



static void Task112(void) {
    while(1) {
        osKill();
    }
}



static void Task113(void) {
    while(1) {
        osKill();
    }
}



static void Task114(void) {
    while(1) {
        osKill();
    }
}



static void Task115(void) {
    while(1) {
        osKill();
    }
}



static void Task116(void) {
    while(1) {
        osKill();
    }
}



static void Task117(void) {
    while(1) {
        osKill();
    }
}



static void Task118(void) {
    while(1) {
        osKill();
    }
}



static void Task119(void) {
    while(1) {
        osKill();
    }
}



static void Task120(void) {
    while(1) {
        osKill();
    }
}



static void Task121(void) {
    while(1) {
        osKill();
    }
}



static void Task122(void) {
    while(1) {
        osKill();
    }
}



static void Task123(void) {
    while(1) {
        osKill();
    }
}



static void Task124(void) {
    while(1) {
        osKill();
    }
}



static void Task125(void) {
    while(1) {
        osKill();
    }
}



static void Task126(void) {
    while(1) {
        osKill();
    }
}



static void Task127(void) {
    while(1) {
        osKill();
    }
}



static void Task128(void) {
    while(1) {
        osKill();
    }
}



static void Task129(void) {
    while(1) {
        osKill();
    }
}



static void Task130(void) {
    while(1) {
        osKill();
    }
}



static void Task131(void) {
    while(1) {
        osKill();
    }
}



static void Task132(void) {
    while(1) {
        osKill();
    }
}



static void Task133(void) {
    while(1) {
        osKill();
    }
}



static void Task134(void) {
    while(1) {
        osKill();
    }
}



static void Task135(void) {
    while(1) {
        osKill();
    }
}



static void Task136(void) {
    while(1) {
        osKill();
    }
}



static void Task137(void) {
    while(1) {
        osKill();
    }
}



static void Task138(void) {
    while(1) {
        osKill();
    }
}



static void Task139(void) {
    while(1) {
        osKill();
    }
}



static void Task140(void) {
    while(1) {
        osKill();
    }
}



static void Task141(void) {
    while(1) {
        osKill();
    }
}



static void Task142(void) {
    while(1) {

        osKill();
    }
}



static void Task143(void) {
    while(1) {
        osKill();
    }
}



static void Task144(void) {
    while(1) {
        osKill();
    }
}



static void Task145(void) {
    while(1) {

        osKill();
    }
}



static void Task146(void) {
    while(1) {
        osKill();
    }
}



static void Task147(void) {
    while(1) {
        osKill();
    }
}



static void Task148(void) {
    while(1) {
        osKill();
    }
}



static void Task149(void) {
    while(1) {
        osKill();
    }
}



static void Task150(void) {
    while(1) {
        osKill();
    }
}



static void Task151(void) {
    while(1) {
        osKill();
    }
}



static void Task152(void) {
    while(1) {
        osKill();
    }
}



static void Task153(void) {
    while(1) {
        osKill();
    }
}



static void Task154(void) {
    while(1) {
        osKill();
    }
}



static void Task155(void) {
    while(1) {
        osKill();
    }
}



static void Task156(void) {
    while(1) {
        osKill();
    }
}



static void Task157(void) {
    while(1) {
        osKill();
    }
}



static void Task158(void) {
    while(1) {
        osKill();
    }
}



static void Task159(void) {
    while(1) {
        osKill();
    }
}



static void Task160(void) {
    while(1) {
        osKill();
    }
}



static void Task161(void) {
    while(1) {
        osKill();
    }
}



static void Task162(void) {
    while(1) {
        osKill();
    }
}



static void Task163(void) {
    while(1) {
        osKill();
    }
}



static void Task164(void) {
    while(1) {
        osKill();
    }
}



static void Task165(void) {
    while(1) {
        osKill();
    }
}



static void Task166(void) {
    while(1) {
        osKill();
    }
}



static void Task167(void) {
    while(1) {
        osKill();
    }
}



static void Task168(void) {
    while(1) {
        osKill();
    }
}



static void Task169(void) {
    while(1) {
        osKill();
    }
}



static void Task170(void) {
    while(1) {
        osKill();
    }
}



static void Task171(void) {
    while(1) {
        osKill();
    }
}



static void Task172(void) {
    while(1) {
        osKill();
    }
}



static void Task173(void) {
    while(1) {
        osKill();
    }
}



static void Task174(void) {
    while(1) {
        osKill();
    }
}



static void Task175(void) {
    while(1) {
        osKill();
    }
}



static void Task176(void) {
    while(1) {
        osKill();
    }
}



static void Task177(void) {
    while(1) {
        osKill();
    }
}



static void Task178(void) {
    while(1) {
        osKill();
    }
}



static void Task179(void) {
    while(1) {
        osKill();
    }
}



static void Task180(void) {
    while(1) {
        osKill();
    }
}



static void Task181(void) {
    while(1) {
        osKill();
    }
}



static void Task182(void) {
    while(1) {
        osKill();
    }
}



static void Task183(void) {
    while(1) {
        osKill();
    }
}



static void Task184(void) {
    while(1) {
        osKill();
    }
}



static void Task185(void) {
    while(1) {
        osKill();
    }
}



static void Task186(void) {
    while(1) {
        osKill();
    }
}



static void Task187(void) {
    while(1) {
        osKill();
    }
}



static void Task188(void) {
    while(1) {
        osKill();
    }
}



static void Task189(void) {
    while(1) {
        osKill();
    }
}



static void Task190(void) {
    while(1) {
        osKill();
    }
}



static void Task191(void) {
    while(1) {
        osKill();
    }
}



static void Task192(void) {
    while(1) {
        osKill();
    }
}



static void Task193(void) {
    while(1) {
        osKill();
    }
}



static void Task194(void) {
    while(1) {
        osKill();
    }
}



static void Task195(void) {
    while(1) {
        osKill();
    }
}



static void Task196(void) {
    while(1) {
        osKill();
    }
}



static void Task197(void) {
    while(1) {
        osKill();
    }
}



static void Task198(void) {
    while(1) {
        osKill();
    }
}



static void Task199(void) {
    while(1) {
        osKill();
    }
}



void Main(void) {
    while(1) {
        osCreateTask(Task0, &task_tcb[0], 100, 0, 5, task_stk[0], STACK_SIZE);
        osCreateTask(Task1, &task_tcb[1], 101, 1, 5, task_stk[1], STACK_SIZE);
        osCreateTask(Task2, &task_tcb[2], 102, 2, 5, task_stk[2], STACK_SIZE);
        osCreateTask(Task3, &task_tcb[3], 103, 3, 5, task_stk[3], STACK_SIZE);
        osCreateTask(Task4, &task_tcb[4], 104, 4, 5, task_stk[4], STACK_SIZE);
        osCreateTask(Task5, &task_tcb[5], 105, 5, 5, task_stk[5], STACK_SIZE);
        osCreateTask(Task6, &task_tcb[6], 106, 6, 5, task_stk[6], STACK_SIZE);
        osCreateTask(Task7, &task_tcb[7], 107, 7, 5, task_stk[7], STACK_SIZE);
        osCreateTask(Task8, &task_tcb[8], 108, 8, 5, task_stk[8], STACK_SIZE);
        osCreateTask(Task9, &task_tcb[9], 109, 9, 5, task_stk[9], STACK_SIZE);
        osCreateTask(Task10, &task_tcb[10], 110, 10, 5, task_stk[10], STACK_SIZE);
        osCreateTask(Task11, &task_tcb[11], 111, 11, 5, task_stk[11], STACK_SIZE);
        osCreateTask(Task12, &task_tcb[12], 112, 12, 5, task_stk[12], STACK_SIZE);
        osCreateTask(Task13, &task_tcb[13], 113, 13, 5, task_stk[13], STACK_SIZE);
        osCreateTask(Task14, &task_tcb[14], 114, 14, 5, task_stk[14], STACK_SIZE);
        osCreateTask(Task15, &task_tcb[15], 115, 15, 5, task_stk[15], STACK_SIZE);
        osCreateTask(Task16, &task_tcb[16], 116, 16, 5, task_stk[16], STACK_SIZE);
        osCreateTask(Task17, &task_tcb[17], 117, 17, 5, task_stk[17], STACK_SIZE);
        osCreateTask(Task18, &task_tcb[18], 118, 18, 5, task_stk[18], STACK_SIZE);
        osCreateTask(Task19, &task_tcb[19], 119, 19, 5, task_stk[19], STACK_SIZE);
        osCreateTask(Task20, &task_tcb[20], 120, 20, 5, task_stk[20], STACK_SIZE);
        osCreateTask(Task21, &task_tcb[21], 121, 21, 5, task_stk[21], STACK_SIZE);
        osCreateTask(Task22, &task_tcb[22], 122, 22, 5, task_stk[22], STACK_SIZE);
        osCreateTask(Task23, &task_tcb[23], 123, 23, 5, task_stk[23], STACK_SIZE);
        osCreateTask(Task24, &task_tcb[24], 124, 24, 5, task_stk[24], STACK_SIZE);
        osCreateTask(Task25, &task_tcb[25], 125, 25, 5, task_stk[25], STACK_SIZE);
        osCreateTask(Task26, &task_tcb[26], 126, 26, 5, task_stk[26], STACK_SIZE);
        osCreateTask(Task27, &task_tcb[27], 127, 27, 5, task_stk[27], STACK_SIZE);
        osCreateTask(Task28, &task_tcb[28], 128, 28, 5, task_stk[28], STACK_SIZE);
        osCreateTask(Task29, &task_tcb[29], 129, 29, 5, task_stk[29], STACK_SIZE);
        osCreateTask(Task30, &task_tcb[30], 130, 30, 5, task_stk[30], STACK_SIZE);
        osCreateTask(Task31, &task_tcb[31], 131, 31, 5, task_stk[31], STACK_SIZE);
        osCreateTask(Task32, &task_tcb[32], 132, 32, 5, task_stk[32], STACK_SIZE);
        osCreateTask(Task33, &task_tcb[33], 133, 33, 5, task_stk[33], STACK_SIZE);
        osCreateTask(Task34, &task_tcb[34], 134, 34, 5, task_stk[34], STACK_SIZE);
        osCreateTask(Task35, &task_tcb[35], 135, 35, 5, task_stk[35], STACK_SIZE);
        osCreateTask(Task36, &task_tcb[36], 136, 36, 5, task_stk[36], STACK_SIZE);
        osCreateTask(Task37, &task_tcb[37], 137, 37, 5, task_stk[37], STACK_SIZE);
        osCreateTask(Task38, &task_tcb[38], 138, 38, 5, task_stk[38], STACK_SIZE);
        osCreateTask(Task39, &task_tcb[39], 139, 39, 5, task_stk[39], STACK_SIZE);
        osCreateTask(Task40, &task_tcb[40], 140, 40, 5, task_stk[40], STACK_SIZE);
        osCreateTask(Task41, &task_tcb[41], 141, 41, 5, task_stk[41], STACK_SIZE);
        osCreateTask(Task42, &task_tcb[42], 142, 42, 5, task_stk[42], STACK_SIZE);
        osCreateTask(Task43, &task_tcb[43], 143, 43, 5, task_stk[43], STACK_SIZE);
        osCreateTask(Task44, &task_tcb[44], 144, 44, 5, task_stk[44], STACK_SIZE);
        osCreateTask(Task45, &task_tcb[45], 145, 45, 5, task_stk[45], STACK_SIZE);
        osCreateTask(Task46, &task_tcb[46], 146, 46, 5, task_stk[46], STACK_SIZE);
        osCreateTask(Task47, &task_tcb[47], 147, 47, 5, task_stk[47], STACK_SIZE);
        osCreateTask(Task48, &task_tcb[48], 148, 48, 5, task_stk[48], STACK_SIZE);
        osCreateTask(Task49, &task_tcb[49], 149, 49, 5, task_stk[49], STACK_SIZE);
        osCreateTask(Task50, &task_tcb[50], 150, 50, 5, task_stk[50], STACK_SIZE);
        osCreateTask(Task51, &task_tcb[51], 151, 51, 5, task_stk[51], STACK_SIZE);
        osCreateTask(Task52, &task_tcb[52], 152, 52, 5, task_stk[52], STACK_SIZE);
        osCreateTask(Task53, &task_tcb[53], 153, 53, 5, task_stk[53], STACK_SIZE);
        osCreateTask(Task54, &task_tcb[54], 154, 54, 5, task_stk[54], STACK_SIZE);
        osCreateTask(Task55, &task_tcb[55], 155, 55, 5, task_stk[55], STACK_SIZE);
        osCreateTask(Task56, &task_tcb[56], 156, 56, 5, task_stk[56], STACK_SIZE);
        osCreateTask(Task57, &task_tcb[57], 157, 57, 5, task_stk[57], STACK_SIZE);
        osCreateTask(Task58, &task_tcb[58], 158, 58, 5, task_stk[58], STACK_SIZE);
        osCreateTask(Task59, &task_tcb[59], 159, 59, 5, task_stk[59], STACK_SIZE);
        osCreateTask(Task60, &task_tcb[60], 160, 60, 5, task_stk[60], STACK_SIZE);
        osCreateTask(Task61, &task_tcb[61], 161, 61, 5, task_stk[61], STACK_SIZE);
        osCreateTask(Task62, &task_tcb[62], 162, 62, 5, task_stk[62], STACK_SIZE);
        osCreateTask(Task63, &task_tcb[63], 163, 63, 5, task_stk[63], STACK_SIZE);
        osCreateTask(Task64, &task_tcb[64], 164, SAME_PRIO, 5, task_stk[64], STACK_SIZE);
        osCreateTask(Task65, &task_tcb[65], 165, SAME_PRIO, 5, task_stk[65], STACK_SIZE);
        osCreateTask(Task66, &task_tcb[66], 166, SAME_PRIO, 5, task_stk[66], STACK_SIZE);
        osCreateTask(Task67, &task_tcb[67], 167, SAME_PRIO, 5, task_stk[67], STACK_SIZE);
        osCreateTask(Task68, &task_tcb[68], 168, SAME_PRIO, 5, task_stk[68], STACK_SIZE);
        osCreateTask(Task69, &task_tcb[69], 169, SAME_PRIO, 5, task_stk[69], STACK_SIZE);
        osCreateTask(Task70, &task_tcb[70], 170, SAME_PRIO, 5, task_stk[70], STACK_SIZE);
        osCreateTask(Task71, &task_tcb[71], 171, SAME_PRIO, 5, task_stk[71], STACK_SIZE);
        osCreateTask(Task72, &task_tcb[72], 172, SAME_PRIO, 5, task_stk[72], STACK_SIZE);
        osCreateTask(Task73, &task_tcb[73], 173, SAME_PRIO, 5, task_stk[73], STACK_SIZE);
        osCreateTask(Task74, &task_tcb[74], 174, SAME_PRIO, 5, task_stk[74], STACK_SIZE);
        osCreateTask(Task75, &task_tcb[75], 175, SAME_PRIO, 5, task_stk[75], STACK_SIZE);
        osCreateTask(Task76, &task_tcb[76], 176, SAME_PRIO, 5, task_stk[76], STACK_SIZE);
        osCreateTask(Task77, &task_tcb[77], 177, SAME_PRIO, 5, task_stk[77], STACK_SIZE);
        osCreateTask(Task78, &task_tcb[78], 178, SAME_PRIO, 5, task_stk[78], STACK_SIZE);
        osCreateTask(Task79, &task_tcb[79], 179, SAME_PRIO, 5, task_stk[79], STACK_SIZE);
        osCreateTask(Task80, &task_tcb[80], 180, SAME_PRIO, 5, task_stk[80], STACK_SIZE);
        osCreateTask(Task81, &task_tcb[81], 181, SAME_PRIO, 5, task_stk[81], STACK_SIZE);
        osCreateTask(Task82, &task_tcb[82], 182, SAME_PRIO, 5, task_stk[82], STACK_SIZE);
        osCreateTask(Task83, &task_tcb[83], 183, SAME_PRIO, 5, task_stk[83], STACK_SIZE);
        osCreateTask(Task84, &task_tcb[84], 184, SAME_PRIO, 5, task_stk[84], STACK_SIZE);
        osCreateTask(Task85, &task_tcb[85], 185, SAME_PRIO, 5, task_stk[85], STACK_SIZE);
        osCreateTask(Task86, &task_tcb[86], 186, SAME_PRIO, 5, task_stk[86], STACK_SIZE);
        osCreateTask(Task87, &task_tcb[87], 187, SAME_PRIO, 5, task_stk[87], STACK_SIZE);
        osCreateTask(Task88, &task_tcb[88], 188, SAME_PRIO, 5, task_stk[88], STACK_SIZE);
        osCreateTask(Task89, &task_tcb[89], 189, SAME_PRIO, 5, task_stk[89], STACK_SIZE);
        osCreateTask(Task90, &task_tcb[90], 190, SAME_PRIO, 5, task_stk[90], STACK_SIZE);
        osCreateTask(Task91, &task_tcb[91], 191, SAME_PRIO, 5, task_stk[91], STACK_SIZE);
        osCreateTask(Task92, &task_tcb[92], 192, SAME_PRIO, 5, task_stk[92], STACK_SIZE);
        osCreateTask(Task93, &task_tcb[93], 193, SAME_PRIO, 5, task_stk[93], STACK_SIZE);
        osCreateTask(Task94, &task_tcb[94], 194, SAME_PRIO, 5, task_stk[94], STACK_SIZE);
        osCreateTask(Task95, &task_tcb[95], 195, SAME_PRIO, 5, task_stk[95], STACK_SIZE);
        osCreateTask(Task96, &task_tcb[96], 196, SAME_PRIO, 5, task_stk[96], STACK_SIZE);
        osCreateTask(Task97, &task_tcb[97], 197, SAME_PRIO, 5, task_stk[97], STACK_SIZE);
        osCreateTask(Task98, &task_tcb[98], 198, SAME_PRIO, 5, task_stk[98], STACK_SIZE);
        osCreateTask(Task99, &task_tcb[99], 199, SAME_PRIO, 5, task_stk[99], STACK_SIZE);
        osCreateTask(Task100, &task_tcb[100], 200, SAME_PRIO, 5, task_stk[100], STACK_SIZE);
        osCreateTask(Task101, &task_tcb[101], 1101, 1, 5, task_stk[101], STACK_SIZE);
        osCreateTask(Task102, &task_tcb[102], 1102, 2, 5, task_stk[102], STACK_SIZE);
        osCreateTask(Task103, &task_tcb[103], 1103, 3, 5, task_stk[103], STACK_SIZE);
        osCreateTask(Task104, &task_tcb[104], 1104, 4, 5, task_stk[104], STACK_SIZE);
        osCreateTask(Task105, &task_tcb[105], 1105, 5, 5, task_stk[105], STACK_SIZE);
        osCreateTask(Task106, &task_tcb[106], 1106, 6, 5, task_stk[106], STACK_SIZE);
        osCreateTask(Task107, &task_tcb[107], 1107, 7, 5, task_stk[107], STACK_SIZE);
        osCreateTask(Task108, &task_tcb[108], 1108, 8, 5, task_stk[108], STACK_SIZE);
        osCreateTask(Task109, &task_tcb[109], 1109, 9, 5, task_stk[109], STACK_SIZE);
        osCreateTask(Task110, &task_tcb[110], 1110, 10, 5, task_stk[110], STACK_SIZE);
        osCreateTask(Task111, &task_tcb[111], 1111, 11, 5, task_stk[111], STACK_SIZE);
        osCreateTask(Task112, &task_tcb[112], 1112, 12, 5, task_stk[112], STACK_SIZE);
        osCreateTask(Task113, &task_tcb[113], 1113, 13, 5, task_stk[113], STACK_SIZE);
        osCreateTask(Task114, &task_tcb[114], 1114, 14, 5, task_stk[114], STACK_SIZE);
        osCreateTask(Task115, &task_tcb[115], 1115, 15, 5, task_stk[115], STACK_SIZE);
        osCreateTask(Task116, &task_tcb[116], 1116, 16, 5, task_stk[116], STACK_SIZE);
        osCreateTask(Task117, &task_tcb[117], 1117, 17, 5, task_stk[117], STACK_SIZE);
        osCreateTask(Task118, &task_tcb[118], 1118, 18, 5, task_stk[118], STACK_SIZE);
        osCreateTask(Task119, &task_tcb[119], 1119, 19, 5, task_stk[119], STACK_SIZE);
        osCreateTask(Task120, &task_tcb[120], 1120, 20, 5, task_stk[120], STACK_SIZE);
        osCreateTask(Task121, &task_tcb[121], 1121, 21, 5, task_stk[121], STACK_SIZE);
        osCreateTask(Task122, &task_tcb[122], 1122, 22, 5, task_stk[122], STACK_SIZE);
        osCreateTask(Task123, &task_tcb[123], 1123, 23, 5, task_stk[123], STACK_SIZE);
        osCreateTask(Task124, &task_tcb[124], 1124, 24, 5, task_stk[124], STACK_SIZE);
        osCreateTask(Task125, &task_tcb[125], 1125, 25, 5, task_stk[125], STACK_SIZE);
        osCreateTask(Task126, &task_tcb[126], 1126, 26, 5, task_stk[126], STACK_SIZE);
        osCreateTask(Task127, &task_tcb[127], 1127, 27, 5, task_stk[127], STACK_SIZE);
        osCreateTask(Task128, &task_tcb[128], 1128, 28, 5, task_stk[128], STACK_SIZE);
        osCreateTask(Task129, &task_tcb[129], 1129, 29, 5, task_stk[129], STACK_SIZE);
        osCreateTask(Task130, &task_tcb[130], 1130, 30, 5, task_stk[130], STACK_SIZE);
        osCreateTask(Task131, &task_tcb[131], 1131, 31, 5, task_stk[131], STACK_SIZE);
        osCreateTask(Task132, &task_tcb[132], 1132, 32, 5, task_stk[132], STACK_SIZE);
        osCreateTask(Task133, &task_tcb[133], 1133, 33, 5, task_stk[133], STACK_SIZE);
        osCreateTask(Task134, &task_tcb[134], 1134, 34, 5, task_stk[134], STACK_SIZE);
        osCreateTask(Task135, &task_tcb[135], 1135, 35, 5, task_stk[135], STACK_SIZE);
        osCreateTask(Task136, &task_tcb[136], 1136, 36, 5, task_stk[136], STACK_SIZE);
        osCreateTask(Task137, &task_tcb[137], 1137, 37, 5, task_stk[137], STACK_SIZE);
        osCreateTask(Task138, &task_tcb[138], 1138, 38, 5, task_stk[138], STACK_SIZE);
        osCreateTask(Task139, &task_tcb[139], 1139, 39, 5, task_stk[139], STACK_SIZE);
        osCreateTask(Task140, &task_tcb[140], 1140, 40, 5, task_stk[140], STACK_SIZE);
        osCreateTask(Task141, &task_tcb[141], 1141, 41, 5, task_stk[141], STACK_SIZE);
        osCreateTask(Task142, &task_tcb[142], 1142, 42, 5, task_stk[142], STACK_SIZE);
        osCreateTask(Task143, &task_tcb[143], 1143, 43, 5, task_stk[143], STACK_SIZE);
        osCreateTask(Task144, &task_tcb[144], 1144, 44, 5, task_stk[144], STACK_SIZE);
        osCreateTask(Task145, &task_tcb[145], 1145, 45, 5, task_stk[145], STACK_SIZE);
        osCreateTask(Task146, &task_tcb[146], 1146, 46, 5, task_stk[146], STACK_SIZE);
        osCreateTask(Task147, &task_tcb[147], 1147, 47, 5, task_stk[147], STACK_SIZE);
        osCreateTask(Task148, &task_tcb[148], 1148, 48, 5, task_stk[148], STACK_SIZE);
        osCreateTask(Task149, &task_tcb[149], 1149, 49, 5, task_stk[149], STACK_SIZE);
        osCreateTask(Task150, &task_tcb[150], 1150, 50, 5, task_stk[150], STACK_SIZE);
        osCreateTask(Task151, &task_tcb[151], 1151, 51, 5, task_stk[151], STACK_SIZE);
        osCreateTask(Task152, &task_tcb[152], 1152, 52, 5, task_stk[152], STACK_SIZE);
        osCreateTask(Task153, &task_tcb[153], 1153, 53, 5, task_stk[153], STACK_SIZE);
        osCreateTask(Task154, &task_tcb[154], 1154, 54, 5, task_stk[154], STACK_SIZE);
        osCreateTask(Task155, &task_tcb[155], 1155, 55, 5, task_stk[155], STACK_SIZE);
        osCreateTask(Task156, &task_tcb[156], 1156, 56, 5, task_stk[156], STACK_SIZE);
        osCreateTask(Task157, &task_tcb[157], 1157, 57, 5, task_stk[157], STACK_SIZE);
        osCreateTask(Task158, &task_tcb[158], 1158, 58, 5, task_stk[158], STACK_SIZE);
        osCreateTask(Task159, &task_tcb[159], 1159, 59, 5, task_stk[159], STACK_SIZE);
        osCreateTask(Task160, &task_tcb[160], 1160, 60, 5, task_stk[160], STACK_SIZE);
        osCreateTask(Task161, &task_tcb[161], 1161, 61, 5, task_stk[161], STACK_SIZE);
        osCreateTask(Task162, &task_tcb[162], 1162, 62, 5, task_stk[162], STACK_SIZE);
        osCreateTask(Task163, &task_tcb[163], 1163, 63, 5, task_stk[163], STACK_SIZE);
        osCreateTask(Task164, &task_tcb[164], 1164, SAME_PRIO, 5, task_stk[164], STACK_SIZE);
        osCreateTask(Task165, &task_tcb[165], 1165, SAME_PRIO, 5, task_stk[165], STACK_SIZE);
        osCreateTask(Task166, &task_tcb[166], 1166, SAME_PRIO, 5, task_stk[166], STACK_SIZE);
        osCreateTask(Task167, &task_tcb[167], 1167, SAME_PRIO, 5, task_stk[167], STACK_SIZE);
        osCreateTask(Task168, &task_tcb[168], 1168, SAME_PRIO, 5, task_stk[168], STACK_SIZE);
        osCreateTask(Task169, &task_tcb[169], 1169, SAME_PRIO, 5, task_stk[169], STACK_SIZE);
        osCreateTask(Task170, &task_tcb[170], 1170, SAME_PRIO, 5, task_stk[170], STACK_SIZE);
        osCreateTask(Task171, &task_tcb[171], 1171, SAME_PRIO, 5, task_stk[171], STACK_SIZE);
        osCreateTask(Task172, &task_tcb[172], 1172, SAME_PRIO, 5, task_stk[172], STACK_SIZE);
        osCreateTask(Task173, &task_tcb[173], 1173, SAME_PRIO, 5, task_stk[173], STACK_SIZE);
        osCreateTask(Task174, &task_tcb[174], 1174, SAME_PRIO, 5, task_stk[174], STACK_SIZE);
        osCreateTask(Task175, &task_tcb[175], 1175, SAME_PRIO, 5, task_stk[175], STACK_SIZE);
        osCreateTask(Task176, &task_tcb[176], 1176, SAME_PRIO, 5, task_stk[176], STACK_SIZE);
        osCreateTask(Task177, &task_tcb[177], 1177, SAME_PRIO, 5, task_stk[177], STACK_SIZE);
        osCreateTask(Task178, &task_tcb[178], 1178, SAME_PRIO, 5, task_stk[178], STACK_SIZE);
        osCreateTask(Task179, &task_tcb[179], 1179, SAME_PRIO, 5, task_stk[179], STACK_SIZE);
        osCreateTask(Task180, &task_tcb[180], 1180, SAME_PRIO, 5, task_stk[180], STACK_SIZE);
        osCreateTask(Task181, &task_tcb[181], 1181, SAME_PRIO, 5, task_stk[181], STACK_SIZE);
        osCreateTask(Task182, &task_tcb[182], 1182, SAME_PRIO, 5, task_stk[182], STACK_SIZE);
        osCreateTask(Task183, &task_tcb[183], 1183, SAME_PRIO, 5, task_stk[183], STACK_SIZE);
        osCreateTask(Task184, &task_tcb[184], 1184, SAME_PRIO, 5, task_stk[184], STACK_SIZE);
        osCreateTask(Task185, &task_tcb[185], 1185, SAME_PRIO, 5, task_stk[185], STACK_SIZE);
        osCreateTask(Task186, &task_tcb[186], 1186, SAME_PRIO, 5, task_stk[186], STACK_SIZE);
        osCreateTask(Task187, &task_tcb[187], 1187, SAME_PRIO, 5, task_stk[187], STACK_SIZE);
        osCreateTask(Task188, &task_tcb[188], 1188, SAME_PRIO, 5, task_stk[188], STACK_SIZE);
        osCreateTask(Task189, &task_tcb[189], 1189, SAME_PRIO, 5, task_stk[189], STACK_SIZE);
        osCreateTask(Task190, &task_tcb[190], 1190, SAME_PRIO, 5, task_stk[190], STACK_SIZE);
        osCreateTask(Task191, &task_tcb[191], 1191, SAME_PRIO, 5, task_stk[191], STACK_SIZE);
        osCreateTask(Task192, &task_tcb[192], 1192, SAME_PRIO, 5, task_stk[192], STACK_SIZE);
        osCreateTask(Task193, &task_tcb[193], 1193, SAME_PRIO, 5, task_stk[193], STACK_SIZE);
        osCreateTask(Task194, &task_tcb[194], 1194, SAME_PRIO, 5, task_stk[194], STACK_SIZE);
        osCreateTask(Task195, &task_tcb[195], 1195, SAME_PRIO, 5, task_stk[195], STACK_SIZE);
        osCreateTask(Task196, &task_tcb[196], 1196, SAME_PRIO, 5, task_stk[196], STACK_SIZE);
        osCreateTask(Task197, &task_tcb[197], 1197, SAME_PRIO, 5, task_stk[197], STACK_SIZE);
        osCreateTask(Task198, &task_tcb[198], 1198, SAME_PRIO, 5, task_stk[198], STACK_SIZE);
        osCreateTask(Task199, &task_tcb[199], 1199, SAME_PRIO, 5, task_stk[199], STACK_SIZE);
        osWait(150);
    }
}
